FEXPSerializeData.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Deserialized rough data, appropriate model assembly.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPSERIALIZEDATA_H_
#define _CFEXPSERIALIZEDATA_H_
#include "FEXPCommon.h"
#include "FEXPSerialization.h"
#include "FEXPSerializeDataTables.h"
#include "FEXPElement.h"
#include "FEXPSetting.h"

class ICFEXPSerialDataBase;
using t_FileStructMap = std::map<std::string, std::function<Ptr<ICFEXPSerialDataBase>()>>;

class ICFEXPSerialDataBase
{
public:
  ICFEXPSerialDataBase(const std::string & identifier, const t_FileTableStructMap & tab_map);
  virtual ~ICFEXPSerialDataBase() { }

  // pure virtual member functions
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) = 0;
  virtual bool ContainsTab(const std::string & key) = 0;

  const std::string GetIdentifier() const;
protected:
  const t_FileTableStructMap & get_cls_map() { return *_tab_map; }

  std::vector<std::string> split_string(const std::string & str, const std::string & delim);
  template<typename TValue>
  TValue convert_string_to(const std::string & txt);
private:
  const std::string                  _identifier;
  t_FileTableStructMap const * const _tab_map;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TValue>
TValue ICFEXPSerialDataBase::convert_string_to(const std::string & str)
//--------------------------------------------------------------------------------------
{
  auto value = str;
  return CFEXPBaseConvers::StringToNumber<TValue>(CFEXPBaseConvers::StrTrim(value));
}

#define INPUT_DATA_CALC_DYNAMICS_CONTAINER_NAME "INPUT_CONTAINER_CALC_DYNAMICS"

class CFEXPCalcDynamic
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPCalcDynamic();
  virtual ~CFEXPCalcDynamic() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA_CALC_DYNAMICS_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }
  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileModelData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPCalcDynamic::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define INPUT_DATA_CALC_MATERIAL_CONTAINER_NAME "INPUT_CONTAINER_CALC_MATERIAL"

class CFEXPCalcMaterial
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPCalcMaterial();
  virtual ~CFEXPCalcMaterial() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA_CALC_MATERIAL_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileModelData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPCalcMaterial::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define INPUT_DATA__CALC_CONSTRAIN_CONTAINER_NAME "INPUT_CONTAINER_CALC_CONSTRAIN"

class CFEXPCalcConstrain
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPCalcConstrain();
  virtual ~CFEXPCalcConstrain() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA__CALC_CONSTRAIN_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileModelData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPCalcConstrain::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define INPUT_DATA_CALC_LOAD_CONTAINER_NAME "INPUT_CONTAINER_CALC_LOAD"

class CFEXPCalcLoad
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPCalcLoad();
  virtual ~CFEXPCalcLoad() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA_CALC_LOAD_CONTAINER_NAME; }
  virtual void CreateData(const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileModelData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPCalcLoad::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define INPUT_DATA_GEOM_NODES_CONTAINER_NAME "INPUT_CONTAINER_GEOM_NODES"

class CFEXPGeomNodes
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPGeomNodes();
  virtual ~CFEXPGeomNodes() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA_GEOM_NODES_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileModelData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPGeomNodes::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}


#define INPUT_DATA_GEOM_ELEMENTS_CONTAINER_NAME "INPUT_CONTAINER_GEOM_ELEMENTS"
class CFEXPGeomElements
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPGeomElements();
  virtual ~CFEXPGeomElements() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA_GEOM_ELEMENTS_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileModelData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPGeomElements::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define SOLVER_CONFIG_INPUT_DATA_CLUSTER_NODES_CONTAINER_NAME "SOLVER_CONFIG_INPUT_CONTAINER_CLUSTER_NODES"

class CFEXPSolverClusterNodes
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPSolverClusterNodes();
  virtual ~CFEXPSolverClusterNodes() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return SOLVER_CONFIG_INPUT_DATA_CLUSTER_NODES_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcConfigFileSolverData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPSolverClusterNodes::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define SOLVER_CONFIG_INPUT_DATA_MODELS_CONTAINER_NAME "SOLVER_CONFIG_INPUT_CONTAINER_FE_MODELS"

class CFEXPSolverFeModels
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPSolverFeModels();
  virtual ~CFEXPSolverFeModels() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return SOLVER_CONFIG_INPUT_DATA_MODELS_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcConfigFileSolverData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPSolverFeModels::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define SOLVER_CONFIG_INPUT_DATA_CALC_BEHAV_CONTAINER_NAME "SOLVER_CONFIG_INPUT_CONTAINER_CALC_BEHAV"

class CFEXPSolverCalcBehaviour
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPSolverCalcBehaviour();
  virtual ~CFEXPSolverCalcBehaviour() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return SOLVER_CONFIG_INPUT_DATA_CALC_BEHAV_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcConfigFileSolverData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPSolverCalcBehaviour::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

#define CALCULATION_RESULT_DATA_MODELS_CONTAINER_NAME "CALCULATION_RESULT_CONTAINER"

class CFEXPCalculationResult
  : public ICFEXPSerialDataBase, public ICFEXPDataContainerBase<CFEXPInpDataTabWrapper, ICFEXPSerialDataTableBase, std::string>
{
public:
  CFEXPCalculationResult();
  virtual ~CFEXPCalculationResult() { }
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return CALCULATION_RESULT_DATA_MODELS_CONTAINER_NAME; }
  virtual void CreateData (const std::string & tab_key, const std::vector<std::string> & tab_def, const std::vector<std::string> & lines) override;
  virtual bool ContainsTab(const std::string & key) override { return Contains(key); }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
  GetTableData();

  const static NmspcFileResData::EFileBlocks ID;
protected:
  const static std::string INERROR;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataTableBase, TData>::value, Ptr<TData>>::type
CFEXPCalculationResult::GetTableData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}

class CFEXPInpDataContainer;
class CFEXPInpDataModelAssemblyFactory
{
public:
  static const t_FileStructMap INP_FILE_BLOCK_CLS_MAP;
  static void AssemblyModelFromInputData(CFEXPInpDataContainer & incont, Ptr<ICFEXPDataModelContIntf> & model_cont, const t_ModelDataKey & model_key);
  static void RemoveModelFromCurrentData(CFEXPInpDataContainer & incont, Ptr<ICFEXPDataModelContIntf> & model_cont);
  // data serialization
  static Ptr<t_SerializedData> SerializeModelCurClcData  (CFEXPInpDataContainer & incont, Ptr<ICFEXPDataModelContIntf> & model_cont);
  static void                  DeserializeModelCurClcData(CFEXPInpDataContainer & incont, Ptr<ICFEXPDataModelContIntf> & model_cont, Ptr<t_SerializedData> ser_data);
protected:
  // [no protected members] -----------------------------
private:
  static void AssemblySettings          (Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont);
  static void AssemblyMaterials         (Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont);
  static void AssemblyConstrains        (Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont);
  static void AssemblyLoads             (Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont);
  static void AssemblyFiniteElementNodes(Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont, const t_ModelDataKey & model_key);
  static void AssemblyFiniteElements    (Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont, const t_ModelDataKey & model_key);
  // removing structure
  static void RemoveFiniteElementNodes(Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont);
  static void RemoveFiniteElements    (Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont);
  // deserializing calculation data
  static void DeserilizeFiniteElementData(Ptr<ICFEXPDataModelContIntf> & model_cont, CFEXPInpDataContainer & incont, Ptr<t_SerializedData> ser_data);
};


class CFEXPSolverInpDataAssemblyFactory
{
public:
  static const t_FileStructMap INP_FILE_BLOCK_CLS_MAP;
  static void AssemblyFromInputData(CFEXPInpDataContainer & incont, Ptr<ICFEXPDataModelContIntf> & model_cont);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPResultDataModelAssemblyFactory
{
public:
  static const t_FileStructMap RES_FILE_BLOCK_CLS_MAP;
  static void AssemblyResultFromInputData(CFEXPInpDataContainer & incont, Ptr<ICFEXPDataModelContIntf> & model_cont, const t_ModelDataKey & model_key);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPInpDataContBase
{
public:
  virtual ~ICFEXPInpDataContBase() { }

  // pure virtual member functions
  virtual void ProcessLines(const std::vector<std::string> & lines) = 0;
protected:
  std::vector<std::string> split_string(const std::string & str, const std::string & delim);
private:
  // [no private members  ] -----------------------------
};


class CFEXPInpDataWrapper
  : public ICFEXPDataWrapperBase<ICFEXPSerialDataBase, std::string>
{
public:
  CFEXPInpDataWrapper(Ptr<ICFEXPSerialDataBase> & data);
  CFEXPInpDataWrapper(const CFEXPInpDataWrapper & source);
  virtual ~CFEXPInpDataWrapper() { }

  // pure virtual member functions
  virtual std::string GetKey() override;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPFEInpContBase
{
public:
  virtual ~CFEXPFEInpContBase() { }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPDataContIntf
  : public CFEXPFEInpContBase
{
public:
  virtual ~ICFEXPDataContIntf() { }
  virtual void SetData(Ptr<ICFEXPDataModelContIntf> model_cont, const t_ModelDataKey & model_key) = 0;
  virtual void RmvData(Ptr<ICFEXPDataModelContIntf> model_cont)                                   = 0;

  // data serialization
  virtual Ptr<t_SerializedData> SerData(Ptr<ICFEXPDataModelContIntf> model_cont)                                 = 0;
  virtual void                  DesData(Ptr<ICFEXPDataModelContIntf> model_cont, Ptr<t_SerializedData> ser_data) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

#define INPUT_DATA_CONTAINER_NAME "INPUT_CONTAINER"

class CFEXPInpDataContainer
  : public ICFEXPDataContIntf, public ICFEXPInpDataContBase, public ICFEXPDataContainerBase<CFEXPInpDataWrapper, ICFEXPSerialDataBase, std::string>
{
public:
  CFEXPInpDataContainer(const t_FileStructMap & clc_map) : _clc_map(&clc_map) { }
  virtual ~CFEXPInpDataContainer() { }

  template<typename TData>
  typename std::enable_if<std::is_base_of<ICFEXPSerialDataBase, TData>::value, Ptr<TData>>::type
  GetInputData();

  // override of virtual member functions
  virtual std::string GetContainerName() const override { return INPUT_DATA_CONTAINER_NAME; }
  virtual void ProcessLines(const std::vector<std::string> & lines) override;

  // override of virtual member functions
  virtual void SetData(Ptr<ICFEXPDataModelContIntf> model_cont, const t_ModelDataKey & model_key) override;
  virtual void RmvData(Ptr<ICFEXPDataModelContIntf> model_cont)                                   override;
  // data serialization
  virtual Ptr<t_SerializedData> SerData(Ptr<ICFEXPDataModelContIntf> model_cont)                                 override;
  virtual void                  DesData(Ptr<ICFEXPDataModelContIntf> model_cont, Ptr<t_SerializedData> ser_data) override;
protected:
  const t_FileStructMap & get_cls_map() const { return *_clc_map; }
private:
  void process_tables      (const std::string & block_key, const std::vector<std::string> & tables);
  bool contains_file_key_id(const std::string & line, const std::string & key);
  std::vector<std::string> get_tab_cols_def(const std::vector<std::string> & tab_def);

 t_FileStructMap const * const _clc_map;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TData>
typename std::enable_if<std::is_base_of<ICFEXPSerialDataBase, TData>::value, Ptr<TData>>::type
CFEXPInpDataContainer::GetInputData()
//--------------------------------------------------------------------------------------
{
  return GetData<TData>();
}


#define SERVER_INPUT_DATA_CONTAINER_NAME "SERVER_INPUT_CONTAINER"
class CFEXPServerInpDataContainer
  : public CFEXPInpDataContainer
{
public:
  CFEXPServerInpDataContainer(const t_FileStructMap & clc_map);
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return SERVER_INPUT_DATA_CONTAINER_NAME; }
  virtual void SetData(Ptr<ICFEXPDataModelContIntf> model_cont, const t_ModelDataKey & model_key) override;
  virtual void RmvData(Ptr<ICFEXPDataModelContIntf> model_cont)                                   override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }

  // data serialization
  virtual Ptr<t_SerializedData> SerData(Ptr<ICFEXPDataModelContIntf> model_cont)                                 override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual void                  DesData(Ptr<ICFEXPDataModelContIntf> model_cont, Ptr<t_SerializedData> ser_data) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

#define RESULT_CONTAINER_NAME "RESULT_CONTAINER"

class CFEXResultDataContainer
  : public CFEXPInpDataContainer
{
public:
  CFEXResultDataContainer(const t_FileStructMap & clc_map);
  // override of virtual member functions
  virtual std::string GetContainerName() const override { return RESULT_CONTAINER_NAME; }
  virtual void SetData(Ptr<ICFEXPDataModelContIntf> model_cont, const t_ModelDataKey & model_key) override;
  virtual void RmvData(Ptr<ICFEXPDataModelContIntf> model_cont)                                   override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }

  // data serialization
  virtual Ptr<t_SerializedData> SerData(Ptr<ICFEXPDataModelContIntf> model_cont)                                 override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
  virtual void                  DesData(Ptr<ICFEXPDataModelContIntf> model_cont, Ptr<t_SerializedData> ser_data) override { FEXPCOMMON_NOT_IMPLEMENTED_EX; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

#endif // !_CFEXPSERIALIZEDATA_H_